#include "mainmeteo.h"
#include "ui_mainmeteo.h"

MainMeteo::MainMeteo(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainMeteo)
{
    ui->setupUi(this);
    this->init();
}

/**
 *Детруктор класса
 *
 */
MainMeteo::~MainMeteo()
{

    if ( animate ){
        animate=false;
        emit stop_animate();
    }
    saveSettings();
    settings->sync();
    delete ui;

}

/**
 *Обработка нажатия на клавишу
 *
 */
void MainMeteo::keyPressEvent(QKeyEvent *event){
   switch (event->key()) {
      case Qt::Key_F11:
           //hidePanel();
           break;
      case Qt::Key_Escape:
           //animatePix_stop();
           //escapePress();
           break;

   }
   event->accept();
}

void MainMeteo::resizeEvent(QResizeEvent *event){
    //windowSize = &size();
    //windowPos  = &pos();
}

void MainMeteo::escapePress(){
    ui->pushButton_2->setChecked(false);
    ui->measureButton->setChecked(false);
    if ( scene!=NULL ){
        scene->cancelAll();
    }
}

/**
 * -------- ИНИЦИАЛИЗАЦИЯ ----------
 *
 */
void MainMeteo::init(){


  //задаем сцену
  scene = new MyMap();
  graphView = new MyGView();
  loadedFiles = NULL;
  createdFiles = NULL;
  loadedPixmap = NULL;
  currentFile  = 0;
  globindex    = 0;
  blockReload  = false;
  globalSet    = NULL;
  globalSet    = new GlobalSetting;
  netAccess    = NULL;
  advMenu      = NULL;
  advLatMenu   = NULL;
  loadBegin    = 0;
  loadSize     = 0;
  speedParams  = NULL;
  speedParamsIndex = 0;

  netAccess = new QNetworkAccessManager;

  globalSet->catPath="";
  globalSet->tmpPath="";
  globalSet->masks.clear();
  globalSet->webitems.clear();
  globalSet->webfiles.clear();
  globalSet->latparams.clear();

  //меню
  advMenu = new QMenu();

  ui->advLatButton->hide();
  QSpinBox *l1 = new QSpinBox();
  l1->setMaximumWidth(60);
  QSpinBox *l2 = new QSpinBox();
  l2->setMaximumWidth(60);
  QHBoxLayout *h1 = new QHBoxLayout();
  QLabel    *t1 = new QLabel(tr("Сколько загрузить:"));
  QWidget   *w1  = new QWidget(NULL);
  h1->addWidget(t1);
  h1->addWidget(l1);
  h1->setSpacing(5);
  h1->setMargin(3);
  w1->setLayout(h1);
  QWidgetAction *wl1 = new QWidgetAction(advMenu);
  wl1->setDefaultWidget( w1 );

  QHBoxLayout *h2 = new QHBoxLayout();
  QLabel    *t2 = new QLabel(tr("Начиная с:"));
  QWidget   *w2  = new QWidget(NULL);
  h2->addWidget(t2);
  h2->addWidget(l2);
  h2->setAlignment(l2,Qt::AlignRight);
  h2->setSpacing(5);
  h2->setMargin(3);
  w2->setLayout(h2);
  QWidgetAction *wl2 = new QWidgetAction(advMenu);
  wl2->setDefaultWidget( w2 );
  advMenu->setTitle(tr("Выбор частичной загрузки"));
  advMenu->addAction(wl1);
  advMenu->addAction(wl2);

  QObject::connect( l1,SIGNAL(valueChanged(int)),this,SLOT(setLoadSize(int)) );
  QObject::connect( l2,SIGNAL(valueChanged(int)),this,SLOT(setLoadBegin(int)) );

  //Меню по широтам
  advLatMenu = new QMenu();
  QListWidget *lw = new QListWidget();
  lw->setObjectName("latWidget");
  lw->setMaximumHeight(100);
  lw->setMaximumWidth(150);
  QWidgetAction *wl3 = new QWidgetAction(advLatMenu);
  wl3->setDefaultWidget( lw );
  advLatMenu->addAction(wl3);

  QObject::connect( lw,SIGNAL(itemClicked(QListWidgetItem*)),this,SLOT(setLatValue(QListWidgetItem*)) );


  speedParams = new QList<ParamManag>;
  ParamManag *item = new ParamManag;
  item->name = tr("Расстояние: %1 км");
  item->value = "0";
  speedParams->append(*item);
  item->name = tr("Разность давления: %1 гПа");
  item->value = "2.5";
  speedParams->append(*item);
  item->name = tr("Широта места: %1 °");
  item->value = "50";
  speedParams->append(*item);
  item->name = tr("Коэффициент: %1");
  item->value = "0.5";
  speedParams->append(*item);
  //qDebug()<<speedParams->at(1).name.arg( speedParams->at(1).value );

  animateTime = 1000;
  animate=false;
  thread = new QThread();
  settings = new QSettings("conf.ini",QSettings::IniFormat);

  blockReload=true;
  readSettings();
  blockReload=false;

  windowSize = new QSize( size() );
  windowPos  = new QPoint( pos() );

  ui->lineEdit_3->setText( QString("%1").arg(animateTime) );

  ui->progressBar->hide();
  this->setAttribute(Qt::WA_QuitOnClose,true);

  this->centralWidget()->layout()->addWidget(graphView);
  //берем картинку

  graphView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
  graphView->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
  graphView->setCursor(Qt::OpenHandCursor);
  graphView->setScene(scene);
  graphView->setDragMode(QGraphicsView::ScrollHandDrag);

  this->setAcceptDrops(true);
  graphView->setAcceptDrops(true);
  graphView->setFocus();


  //создаем каталог с картинками
  QDir *mydir = new QDir( globalSet->catPath );
  if ( !mydir->exists()&&globalSet->catPath!="" ) mydir->mkpath("./");
  QStringList list = mydir->entryList( QDir::Files | QDir::NoDotAndDotDot );
  QCompleter *completer = new QCompleter(list,this);
  completer->setCaseSensitivity(Qt::CaseInsensitive);
  ui->maskEdit->setCompleter(completer);
  ui->maskBox->addItems( globalSet->masks );
  if ( globalSet->webitems.size()>0 ){
      for ( int i=0; i<globalSet->webitems.size(); i++ )
          ui->maskBox->addItem( "[Web] "+QString(globalSet->webitems.at(i).name)+
                                QString(" [%1]").arg( globalSet->webitems.at(i).files.split(',').size() ) );
  }

  //создаем временный каталог
  if ( globalSet->tmpPath=="" ) globalSet->tmpPath = "tmp";
  QDir *tmpdir = new QDir( globalSet->tmpPath );
  if ( !tmpdir->exists()&&globalSet->tmpPath!="" ) {
      tmpdir->mkpath("./");
  }



  QObject::connect( graphView,SIGNAL(changePix(int)),this,SLOT(changePix(int)) );
  QObject::connect( graphView,SIGNAL(hidePanel()),this,SLOT(hidePanel()) );
  //QObject::connect( this,SIGNAL(animatePix()),this,SLOT(animatePix_slot()) );
  QObject::connect( graphView,SIGNAL(dropFiles(QStringList*)),this,SLOT(dropFiles(QStringList*))  );
  QObject::connect( graphView,SIGNAL(gvPress(QPoint*)),scene,SLOT(startLine(QPoint*)));
  QObject::connect( graphView,SIGNAL(escapePress()),this,SLOT(escapePress()));

  QObject::connect( scene,SIGNAL(lineScale(int)),this,SLOT(lineScale(int)));
  QObject::connect( scene,SIGNAL(lineMeasure(float)),this,SLOT(lineMeasure(float)));

  QObject::connect( netAccess, SIGNAL(finished(QNetworkReply*)), this, SLOT(slot_netManagerFinished(QNetworkReply*)));

  QObject::connect( thread,SIGNAL(started()),this,SLOT(animatePix_start()) );
  QObject::connect( this,SIGNAL( stop_animate() ),thread,SLOT(terminate()) );

}

/**
 * ЗАГРУЗКА файлов в переменные по МАСКЕ
 *
 */
void MainMeteo::getFileNames( QString *mask ){
  QDir *dir;
  dir = new QDir( globalSet->catPath );
  //qDebug()<<globalSet->catPath;

  dir->setFilter( QDir::Files | QDir::Hidden | QDir::AccessMask );
  dir->setSorting( QDir::Name | QDir::Reversed | QDir::Time );
  dir->setNameFilters( QStringList(*mask) );

  QFileInfoList *list = new QFileInfoList(dir->entryInfoList());
  QFileInfo *file;
  loadedFiles = NULL;
  createdFiles = NULL;
  loadedFiles = new QStringList();
  createdFiles = new QStringList();
  if ( list->size()>0 ){
   int sizeL,sizeB;
   if ( list->size()>=loadBegin+loadSize && loadSize>0 )
       sizeL = loadSize;
   else sizeL = list->size();
   if ( loadBegin<=list->size() && loadBegin>=0 )
       sizeB = loadBegin;
   else sizeB=0;
   for ( int i=sizeB; i<sizeL; i++ ){
    file = new QFileInfo( list->at(i) );
    //qDebug()<<file->fileName();
    loadedFiles->append( file->absoluteFilePath() );
    createdFiles->append( file->lastModified().toString("dd.MM") );
    //qDebug()<<file->lastModified().toString("dd.MM");
    file = NULL;
    delete file;
   }//endfor
   ui->horizontalSlider->setMinimum( 0 );
   ui->horizontalSlider->setValue(0 );
   ui->horizontalSlider->setMaximum( loadedFiles->size()-1 );
   loadFiles(loadedFiles);
  }else{
      ui->statusBar->showMessage( tr("Не найдено файлов по маске '")+*mask+tr("' ") );
  }
  list = NULL;
  dir  = NULL;
  delete list;
  delete dir;
  return;
}

/**
 * перегруженная функция для загрузки файлов из списка напрямую
 *
 */
void MainMeteo::getFileNames( QStringList *files ){

  QFileInfo *file;
  loadedFiles = NULL;
  createdFiles = NULL;
  loadedFiles = new QStringList();
  createdFiles = new QStringList();
  /*
  int sizeL,sizeB;
  if ( files->size()>=loadBegin+loadSize && loadSize>0 )
      sizeL = loadSize;
  else sizeL = files->size();
  if ( loadBegin<=files->size() && loadBegin>=0 )
      sizeB = loadBegin;
  else sizeB=0;*/
  for ( int i=0; i<files->size(); i++ ){
  //for ( int i=0; i<files->size(); i++ ){
    file = new QFileInfo( files->at(i) );
    //qDebug()<<file->fileName();
    loadedFiles->append( files->at(i) );
    createdFiles->append( file->lastModified().toString("dd.MM") );
    //qDebug()<<file->lastModified().toString("dd.MM");
    file = NULL;
  }//endfor
  ui->horizontalSlider->setMinimum( 0 );
  ui->horizontalSlider->setValue(0);
  ui->horizontalSlider->setMaximum( loadedFiles->size()-1 );
  loadFiles(loadedFiles);

  file = NULL;
  delete file;
  return;
}


/**
 * загрузка картинок из сети
 *
 */
void MainMeteo::downloadImages(QStringList *list){

    //netAccess = new QNetworkAccessManager();

    int size;
    size = list->size();
    globindex=0;


    ui->progressBar->setMaximum(size);
    ui->progressBar->setMinimum(0);
    ui->progressBar->setValue(0);
    ui->progressBar->show();
    ui->statusBar->showMessage( tr("Начинается загрузка, подождите...") );

    for ( int i=0;i<size;i++ ){
      /*QFileInfo *fileinfo = new QFileInfo( list->at(i) );//выдираем информацию о файле
      QFile *file = new QFile;
      file->setFileName( globalSet->tmpPath+"\\"+fileinfo->fileName() );
      if ( !file->exists() ) {*/
        QUrl *imageUrl = new QUrl( list->at(i) );
        QNetworkRequest *request = new QNetworkRequest(*imageUrl);
        netAccess->get(*request);
        imageUrl = NULL;
        request  = NULL;
        delete request;
        delete imageUrl;
    }

}

/**
 * [SLOT]
 * конец загрузки
 */
void MainMeteo::slot_netManagerFinished(QNetworkReply *reply){

    ui->statusBar->showMessage( tr("Загрузка файла ")+globalSet->webfiles.at(globindex)+"..." );
    if (reply->error() != QNetworkReply::NoError) {
    qDebug() << "Error in" << reply->url() << ":" << reply->errorString();
    return;
    }
    QVariant *attribute = new  QVariant(reply->attribute(QNetworkRequest::RedirectionTargetAttribute));
    if (attribute->isValid()) {
    QUrl url = attribute->toUrl();
    qDebug() << "must go to:" << url;
    return;
    }
    qDebug() << "ContentType:" << reply->header(QNetworkRequest::ContentTypeHeader).toString();
    //qDebug() << "file:" << reply->url();
    /*
    QByteArray *jpegData = new QByteArray(reply->readAll());

    QPixmap *pixmap = new QPixmap();
    pixmap->loadFromData(*jpegData); //reply->url().toString().section('/', -1)
    pixmap->save( globalSet->tmpPath+"\\"+globalSet->webfiles.at(globindex) );
    */

    QFileInfo *fileinfo = new QFileInfo( reply->url().path() );
    //qDebug()<<fileinfo->fileName()<<fileinfo->size()<<fileinfo->created();
    QFile *file = new QFile;
    file->setFileName( globalSet->tmpPath+"\\"+fileinfo->fileName() );
    //если файла нет
    //если он новее
    //если пофиг
    //if ( !file->exists() ) {
      file->open(QIODevice::WriteOnly);
      file->write(reply->readAll());
      file->close();
    //}

    globindex++;
    ui->progressBar->setValue( globindex );
    //if ( globalSet->webfiles.size()==globindex ){
    int size;
    size = globalSet->webfiles.size();
    int sizeL,sizeB;
    if ( size>=loadBegin+loadSize && loadSize>0 )
        sizeL = loadSize;
    else sizeL = size;
    if ( loadBegin<=size && loadBegin>=0 )
        sizeB = loadBegin;
    else sizeB=0;
    if ( (sizeL-sizeB)==globindex ){
        ui->progressBar->hide();
        QStringList *files = new QStringList();
        //for ( int i=0;i<globalSet->webfiles.size();i++ ){
        for ( int i=sizeB;i<sizeL;i++ ){
            files->append( globalSet->tmpPath+"\\"+globalSet->webfiles.at(i) );
            //qDebug()<<globalSet->tmpPath+"\\"+globalSet->webfiles.at(i);
        }
        getFileNames( files );
        files = NULL;
        delete files;
    }

    attribute = NULL;
    file = NULL;
    fileinfo = NULL;
    delete fileinfo;
    delete file;
    delete attribute;
    reply->deleteLater();
    return;
}

/**
 * загружает все файлы в память
 * ассоциирует их с листалкой
 *
 */
bool MainMeteo::loadFiles( QStringList *filenames ){

  if ( loadedPixmap == NULL ){
      loadedPixmap = new QList<QPixmap>;
  }
  if ( !loadedPixmap->isEmpty() ){
    while (!loadedPixmap->isEmpty())
         delete &loadedPixmap->takeFirst();
  }
  ui->progressBar->setMaximum(filenames->size());
  ui->progressBar->setMinimum(0);
  ui->progressBar->setValue(0);
  ui->progressBar->show();
  scene->clear();
  scene->clear_map();

  graphView->viewport()->update();

  if ( filenames->size()>0 ){
  for ( int i=0; i<filenames->size();i++ ){
      QPixmap *pix = new QPixmap(filenames->at(i));
      loadedPixmap->append( *pix );
      qDebug()<<filenames->at(i);
      ui->statusBar->showMessage( tr("Файл: ")+filenames->at(i)+tr(", Создан: ")+createdFiles->at(i) )  ;
      ui->progressBar->setValue(i);
      pix = NULL;
      delete pix;
  }//endfor

  scene->setMap( loadedPixmap->first() );
  scene->setSceneRect( 0,0,loadedPixmap->first().width(),loadedPixmap->first().height() );
  ui->progressBar->setValue( filenames->size() );
  ui->progressBar->hide();
  refreshHeader();
  }

  return true;
}


/**
 * Выводим нужную картинку по номеру
 *
 */
void MainMeteo::showPix( int pix ){
    if ( loadedPixmap->size()>=pix ){
      scene->setMap( loadedPixmap->at(pix) );
      scene->refresh();
      currentFile = pix;
      ui->statusBar->showMessage( tr("Файл: ")+loadedFiles->at(pix)+tr(", Создан: ")+createdFiles->at(pix) )  ;
      refreshHeader();
    }
}

/**
 * Обработка нажания на Enter в поле ввода маски
 *
 */
void MainMeteo::on_maskEdit_returnPressed()
{
    QString *mask = new QString( ui->maskEdit->text() );
    getFileNames(mask);
    blockReload = true;
    on_maskButton_clicked();
    mask = NULL;
    delete mask;
}

/**
 * Обработка изменения позиции слайдера картинок
 *
 */
void MainMeteo::on_horizontalSlider_valueChanged(int value)
{
   showPix(value);
}

/**
 * Смена картинки по шагу слайдера
 *
 */
void MainMeteo::changePix(int step){
    if ( step>0 ){
      if ( ui->horizontalSlider->value()<ui->horizontalSlider->maximum() ){
        ui->horizontalSlider->setValue( ui->horizontalSlider->value()+step );
      }else{
        ui->horizontalSlider->setValue( 0 );
      }
    }else{
      if ( ui->horizontalSlider->value()>ui->horizontalSlider->minimum() ){
        ui->horizontalSlider->setValue( ui->horizontalSlider->value()+step );
      }else{
        ui->horizontalSlider->setValue( ui->horizontalSlider->maximum() );
      }
    }
    return;
}

/**
 * Обработка нажатия на кнопку добавления маски
 *
 */
void MainMeteo::on_maskButton_clicked()
{
    QString *mask = new QString( ui->maskEdit->text() );
    if ( ui->maskBox->findText(*mask)==-1&&!mask->isEmpty() ){
        if ( ui->maskBox->itemText(0).isEmpty() ) ui->maskBox->setItemText( 0,*mask );
        else {
            ui->maskBox->addItem(*mask);
            ui->maskBox->setCurrentIndex( ui->maskBox->count()-1 );
        }
        if ( blockReload ) blockReload=false;
    }
    mask = NULL;
    delete mask;
    return;
}

/**
 * Обработка выбора из списка доступных масок
 *
 */
void MainMeteo::on_maskBox_currentIndexChanged(QString val)
{
    ui->maskEdit->setText(val);
    if (!blockReload)  {
        if ( val.contains( "[Web]" ) ){
          QString *name = new QString( val.replace( "[Web]","" ).trimmed() );
          for ( int i=0; i < globalSet->webitems.size(); i++ ){
              if ( *name == globalSet->webitems.at(i).name){
                  //QStringList *list;
                  globalSet->webfiles.clear();
                  //while (!globalSet->webfiles.isEmpty())
                  //     delete &globalSet->webfiles.takeFirst();

                  globalSet->webfiles = globalSet->webitems.at(i).files.split(",");
                  QStringList *download;
                  download = new QStringList();

                  int size;
                  size = globalSet->webfiles.size();
                  int sizeL,sizeB;
                  if ( size>=loadBegin+loadSize && loadSize>0 )
                      sizeL = loadSize;
                  else sizeL = size;
                  if ( loadBegin<=size && loadBegin>=0 )
                      sizeB = loadBegin;
                  else sizeB=0;

                  for ( int j=sizeB;j<sizeL ;j++ ){
                      download->append( QString( globalSet->webitems.at(i).url ) + globalSet->webfiles.at(j) );
                  }

                  downloadImages(download);
                  download = NULL;
                  delete download;
              }
          }
          name = NULL;
          delete name;
        }else getFileNames( &val );
    }
}

/**
 * Скрытие панели при разворачивании
 * Выставление окна без рамки и прочего
 */
void MainMeteo::hidePanel(){
    if ( ui->groupBox->isHidden() ){
       ui->groupBox->show();
       ui->groupBox_2->show();
       ui->groupBox_3->show();
       ui->groupBox_4->show();
       ui->groupBox_5->show();
       QWidget::setWindowFlags(Qt::Window);
       this->setAttribute(Qt::WA_QuitOnClose,true);

       this->resize( windowSize->width(),windowSize->height() );
       this->move( windowPos->x(),windowPos->y() );
       this->showNormal();

    }else{
       ui->groupBox->hide();
       ui->groupBox_2->hide();
       ui->groupBox_3->hide();
       ui->groupBox_4->hide();
       ui->groupBox_5->hide();
       //windowSize = &QSize(size());
       //windowPos  = &QPoint(this->x(),this->y());
       QWidget::setWindowFlags(Qt::SplashScreen | Qt::WindowStaysOnTopHint);
       this->setAttribute(Qt::WA_QuitOnClose,true);
       //this->show();
       this->showMaximized();
    }
}


/**
 * Обработка нажатия кнопки анимации, запуск анимации
 *
 */
void MainMeteo::on_pushButton_6_clicked()
{

    if ( loadedPixmap==NULL || loadedPixmap->isEmpty() ){
        ui->statusBar->showMessage( tr("Необходимо загрузить файлы! ") )  ;
        return;
    }
    if ( loadedPixmap->size()==1 ){
        ui->statusBar->showMessage( tr("Анимация возможна для двух и более файлов! ") )  ;
        return;
    }

    if ( animate ){
      animatePix_stop();
    }else{
      ui->pushButton_6->setText(tr("Стоп!"));
      ui->pushButton_6->setIcon( QIcon(":/icons/icons/Stop-icon.png") );
      animate=true;
      thread->start();//запускаем процесс

    }
}

/**
 * Перекидывание файлов в окно, их открытие
 *
 */
void MainMeteo::dropFiles(QStringList *files){
    getFileNames(files);
}

/**
 * Старт Анимации
 *
 */
void MainMeteo::animatePix_start(){
    float tim;
    tim = ui->lineEdit_3->text().toFloat();//интервал засыпания
    QEventLoop loop;

    while (animate){
       if ( ui->horizontalSlider->value()<ui->horizontalSlider->maximum() ){
           ui->horizontalSlider->setValue( ui->horizontalSlider->value()+1 );
           //showPix(  );
       }else{
           ui->horizontalSlider->setValue( 0 );
           //showPix(0);
       }
       loop.processEvents();
       thread->wait(tim);

    }

}

/**
 * Остановка анимации
 *
 */
void MainMeteo::animatePix_stop(){
    if ( animate ){
        animate=false;
        emit stop_animate();
        ui->pushButton_6->setText(tr("Пуск!"));
        ui->pushButton_6->setIcon( QIcon(":/icons/icons/Play-icon.png") );
    }
    return;
}

/**
 * Чтение настроек из файла
 * settings - переменная настроек
 */
void MainMeteo::readSettings(){
    settings->setIniCodec("utf8");

    //группа главного окна и положения
    settings->beginGroup("MainWindow");
    resize(settings->value("size", QSize(600, 400)).toSize());
    move(settings->value("pos", QPoint(200, 200)).toPoint());
    if ( settings->value("maximized").toBool() )  this->showMaximized();
    settings->endGroup();

    //сохраненные маски
    settings->beginGroup("MaskFilter");
    if ( settings->value("mask").toString().split("|").size()>0 ){
      globalSet->masks.append( settings->value("mask").toString().split("|") );
    }
    settings->endGroup();

    //загружаем каталоги
    settings->beginGroup("Paths");
    globalSet->catPath = settings->value("catalogPath").toString();
    globalSet->tmpPath = settings->value("tmpPath").toString();
    settings->endGroup();

    //загружаем пункты HTTP поиска
    int sizeWeb;
    sizeWeb = settings->beginReadArray("WebPreset");
    //globalSet->webitems.clear();
    while (!globalSet->webitems.isEmpty())
         delete &globalSet->webitems.takeFirst();

    for ( int i=0; i<sizeWeb; ++i ){
      settings->setArrayIndex(i);
      WebItem *item = new WebItem;
      item->name = settings->value("name").toString();
      item->url = settings->value("URL").toString();
      item->files = settings->value("files").toString();
      globalSet->webitems.append(*item);
      item = NULL;
      delete item;
    }
    settings->endArray();

    //загружаем пункты широты
    int sizeLat;
    sizeLat = settings->beginReadArray("CityLat");
    while (!globalSet->latparams.isEmpty())
         delete &globalSet->latparams.takeFirst();

    QListWidget *lw = advLatMenu->findChild<QListWidget *>("latWidget");
    for ( int i=0; i<sizeWeb; ++i ){
      settings->setArrayIndex(i);
      ParamManag *item = new ParamManag;
      item->name = settings->value("name").toString();
      item->value = settings->value("Lat").toString();
      globalSet->latparams.append(*item);
      lw->addItem( item->name );
      item = NULL;
      delete item;
    }
    settings->endArray();

    //загрузка маштаба
    float km;
    km=0;
    settings->beginGroup("ScaleParam");
    if ( settings->value("scale").toFloat()>0 )
      km = 100/settings->value("scale").toFloat();
    else km=100;
    scene->setScale( 100,km );
    globalSet->scale = scene->getScale();
    ui->scalePxEdit->setText( "100" );
    ui->scaleKmEdit->setText( QString("%1").arg( round(km) ) );
    ui->scaleLabel->setText( QString("100:%1").arg(round(km)) );
    settings->endGroup();
}

/**
 *
 * Запись настроек в переменную
 * settings - переменная настроек
 */
void MainMeteo::saveSettings(){
    settings->setIniCodec("utf-8");

    //сохраняем размер и положение окна
    settings->beginGroup("MainWindow");
    settings->setValue("maximized", this->isMaximized() );
    if ( !this->isMaximized() ) {
        settings->setValue("size", size());
        settings->setValue("pos", pos());
    }
    settings->endGroup();

    //сохраняем вбитые маски
    int count; //их количество
    count = ui->maskBox->count();
    if ( count!=0 ){ //есди они вообще есть
      QStringList *masks; //сами маски
      masks = new QStringList();
      for ( int i=0; i<count; i++ ){
          if ( !ui->maskBox->itemText(i).isEmpty()&&!ui->maskBox->itemText(i).contains("[Web]") )
            masks->append( ui->maskBox->itemText(i) );
      }
      settings->beginGroup("MaskFilter");
      settings->setValue("mask", QVariant(masks->join("|")).toString() ); //сохраняем
      settings->endGroup();
      masks = NULL;
      delete masks;
    }//endif

    //сохраняем масштаб
    float scale;
    scale=0;
    scale = scene->getScale();
    if ( scale!=0 ){
        settings->beginGroup("ScaleParam");
        settings->setValue("scale", QVariant( scale ).toDouble() ); //сохраняем
        settings->endGroup();
    }

}


/**
 * Нажатие на кнопку "Задать масштаб"
 *
 */
void MainMeteo::on_pushButton_2_toggled(bool checked)
{
    if ( ui->measureButton->isChecked() ) ui->measureButton->setChecked(false);
    if ( checked ){ //если выбран "задать масштаб"
      if ( scene!=NULL ){
          scene->cancelAll();
      }
      graphView->viewport()->setCursor( QCursor( QPixmap(":/icons/icons/ruler-pencil-icon_cursor.png"),3,3 ) );
      scene->setTool(1);
      graphView->anothercursor = true;
    }else{//если уже задали
      graphView->anothercursor = false;
      graphView->viewport()->setCursor(Qt::OpenHandCursor);
    }
}

/** [SLOT]
 * Запись расстояния в пикселях в поле
 * scalePxEdit
 */
void MainMeteo::lineScale(int line){
    ui->scalePxEdit->setText( QString("%1").arg(line) );
    ui->pushButton_2->setChecked(false);
    ui->scaleKmEdit->setFocus();
    ui->scaleKmEdit->selectAll();
}

/**
 * нажатие на Enter после задания масштаба
 * scaleKmEdit
 */
void MainMeteo::on_scaleKmEdit_returnPressed()
{
  on_scaleButton_clicked();
}

/**
 * нажатие  после задания масштаба
 * scaleButton
 */
void MainMeteo::on_scaleButton_clicked()
{
    if ( !ui->scaleKmEdit->text().isEmpty()&&ui->scaleKmEdit->text()!="0" ){
       if ( scene->isNullLine() ){
         scene->setScale( ui->scalePxEdit->text().toFloat(),ui->scaleKmEdit->text().toFloat() );
       }
       else{
         scene->setScale( ui->scaleKmEdit->text().toFloat() );
         if ( scene->getTool() == 1 ){
           QLineF *line = new QLineF();
           scene->setLine( line );
           line= NULL;
           delete line;
         }
       }
       //задаем масштаб (выводим)
       ui->scaleLabel->setText( QString("100:%2").arg( int( 1/scene->getScale()*100) ) );
       if ( scene->getTool() == 2 ){
           scene->setScale( ui->scalePxEdit->text().toFloat(),ui->scaleKmEdit->text().toFloat() );
           scene->lineMeasure_emit();
       }
    }
}

/**
 * нажатие на кнопку измерения расстояния
 * measureButton
 */
void MainMeteo::on_measureButton_toggled(bool checked)
{
    if ( ui->pushButton_2->isChecked() ) ui->pushButton_2->setChecked(false);
    if ( checked ){ //если выбран "задать масштаб"
      if ( scene!=NULL ){
        scene->cancelAll();
      }
      graphView->viewport()->setCursor( QCursor( QPixmap(":/icons/icons/ruler-icon_cursor.png"),3,3 ) );
      graphView->anothercursor = true;
      scene->setTool(2);
    }else{//если уже задали
      graphView->anothercursor = false;
      graphView->viewport()->setCursor(Qt::OpenHandCursor);
    }
}

/** [SLOT]
 * вывод в поле измеренного расстояния
 * measureLabel
 */
void MainMeteo::lineMeasure(float line){
    ui->measureLabel->setText( QString(tr("%1 км")).arg( round(line) ) );
    ui->speedKmEdit->setText( QString(tr("%1")).arg( round(line) ) );
    setvalueParam(0, QString("%1").arg( round(line) ) );

    ui->measureButton->setChecked(false);
}

/** [SLOT]
 * перезагрузка настроек
 *
 */
void MainMeteo::reloadSettings(){
    blockReload=true;
    ui->maskBox->clear();
    readSettings();
    blockReload=false;
}

/**
 * нажатие на Enter после ввода пикселей
 */
void MainMeteo::on_scalePxEdit_returnPressed()
{
    ui->scaleKmEdit->setFocus();
    ui->scaleKmEdit->selectAll();
}

void MainMeteo::refreshHeader(){
    this->setWindowTitle( tr("Метеоанализатор - выбрано %1 из %2").arg( currentFile+1 ).arg(loadedPixmap->size()) );
}

// [MENU] полноэкранный режим
void MainMeteo::on_action_5_triggered(bool checked)
{
  hidePanel();
}

// [MENU] задать масштаб
void MainMeteo::on_action_2_triggered()
{
  ui->pushButton_2->setChecked(true);
}

// [MENU] настройки
void MainMeteo::on_action_4_triggered()
{
    settingWindow *set = new settingWindow(this);
    set->show();
    QObject::connect( set,SIGNAL(reloadSettings()),this,SLOT(reloadSettings()) );
    set = NULL;
    delete set;
}

// [MENU] обновить
void MainMeteo::on_action_3_triggered()
{
    if ( graphView ) graphView->viewport()->repaint();
}

// [MENU] справка
void MainMeteo::on_action_6_triggered()
{
    about *set = new about(this);
    set->show();
    set = NULL;
    delete set;
}

// [MENU] измерить
void MainMeteo::on_action_7_triggered()
{
  ui->measureButton->setChecked(true);
}

// [MENU] измерить
void MainMeteo::on_action_triggered()
{
    this->close();
}
// [MENU] отмена
void MainMeteo::on_action_10_triggered()
{
    animatePix_stop();
    escapePress();
}
// [MENU] предыдущая
void MainMeteo::on_action_9_triggered()
{
  emit changePix(-1);
}
// [MENU]  следующая
void MainMeteo::on_action_8_triggered()
{
  emit changePix(1);
}
// [MENU]  Помощь
void MainMeteo::on_action_11_triggered()
{
    Help *set = new Help(this);
    set->show();
    set = NULL;
    delete set;
}

/** [SLOT]
 * расчет скорости перемещения
 *
 */
void MainMeteo::on_speedButton_clicked()
{
    if ( ui->speedTimeLineEdit->text().toFloat()!=0 && ui->speedTimeLineEdit->text()!="" ){
        ui->speedLabel->setText( QString(tr("%1 км/ч")).arg( round( ui->speedKmEdit->text().toFloat()/ui->speedTimeLineEdit->text().toFloat() ) ) );
    }
}

/** [SLOT]
 * расчет скорости
 *
 */
void MainMeteo::on_speedTimeLineEdit_returnPressed()
{
    ui->speedButton->click();
}

/** [SLOT]
 * предыдущая картинка
 *
 */
void MainMeteo::on_leftButton_clicked()
{
    changePix(1);
}

/** [SLOT]
 * следующая картинка
 *
 */
void MainMeteo::on_rightButton_clicked()
{
    changePix(-1);
}

/** [SLOT]
 * активация окна с расширенными параметрами
 *
 */
void MainMeteo::on_advButton_clicked()
{
  advMenu->move( mapToGlobal(ui->advButton->pos()).x(),mapToGlobal(ui->advButton->pos()).y()+ui->advButton->height() );
  advMenu->exec();
}

/** [SLOT]
 * активация окна с расширенными параметрами
 *
 */
void MainMeteo::setLoadBegin(int s){
  loadBegin = s;
}

/** [SLOT]
 * активация окна с расширенными параметрами
 *
 */
void MainMeteo::setLoadSize(int s){
  loadSize = s;
}

/** [SLOT]
 * активация окна с выбором широты
 *
 */
void MainMeteo::on_advLatButton_clicked()
{
  advLatMenu->move( (ui->advLatButton->parentWidget()->mapToGlobal(ui->advLatButton->pos())).x(),
                    (ui->advLatButton->parentWidget()->mapToGlobal(ui->advLatButton->pos())).y()+
                    ui->advLatButton->height()/2 );
  advLatMenu->exec();
}

void MainMeteo::setLatValue(QListWidgetItem *item){
    int sizeLat;
    sizeLat = globalSet->latparams.size();
    QString text;
    text = item->text();
    for ( int i=0;i<sizeLat;i++ ){
        if ( text == globalSet->latparams.at(i).name ){
          ui->paramEdit->setText( globalSet->latparams.at(i).value );
          setvalueParam( speedParamsIndex, ui->paramEdit->text() );
        }
    }
}

/**
 * выбор параметра для изменения
 * @brief MainMeteo::on_paramComboBox_activated
 * @param index
 */
void MainMeteo::on_paramComboBox_activated(int index)
{
  ui->paramEdit->setText( speedParams->at(index).value );
  ui->paramnamelabel->setText( speedParams->at(index).name.section(":",0,0)+":" );
  if ( index==2 ) ui->advLatButton->show();
  else ui->advLatButton->hide();
  speedParamsIndex = index;
}

/**
 * заменяем занчение параметра
 * @brief MainMeteo::on_paramEdit_textChanged
 * @param arg1
 */
void MainMeteo::on_paramEdit_textEdited(const QString &arg1)
{
    setvalueParam( speedParamsIndex, arg1 );
}

/**
 * Установка значений в параметре
 * @brief MainMeteo::setvalueParam
 * @param index
 * @param value
 */
void MainMeteo::setvalueParam(int index, QString value){
    ParamManag *item = new ParamManag;
    item->name = speedParams->at( index ).name;
    item->value = value;
    speedParams->replace( index, *item );
    ui->paramComboBox->setItemText( index, speedParams->at( index ).name.arg(speedParams->at( index ).value) );
    return;
}

/**
 * Расчет расстояния по формуле
 * @brief MainMeteo::on_calcSpeedButton_clicked
 */
void MainMeteo::on_calcSpeedButton_clicked()
{
  float ret,f,p,n,dp,c;
  //расчет по формуле V = 4.8/sin(f) * dP/dn * c
  p = speedParams->at(1).value.toFloat(); //разность давление
  n = speedParams->at(0).value.toFloat(); //разность расстояния
  f = speedParams->at(2).value.toFloat(); //градус широты
  c = speedParams->at(3).value.toFloat(); //коэффициент
  if ( n==0 || sin( f*PI/180 )==0 ){
    ui->speedlabel->setText( QString( tr("Деление на 0!") ) );
  }else{
    dp = 111*p/n; //приведенное к меридиану давление
    ret = 4.8*dp*c/( sin( f*PI/180 ) );
    ui->speedlabel->setText( QString( tr("%1 м/с") ).arg( round(ret) ) );
  }
  //qDebug()<< sin( f*PI/180 );
}


